home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / network / ncsasock / socket.c < prev    next >
Text File  |  1996-07-05  |  42KB  |  1,717 lines
  1. /*
  2.  * BSD-style socket emulation library for the Mac
  3.  * Original author: Tom Milligan
  4.  * Current author: Charlie Reiman - creiman@ncsa.uiuc.edu
  5.  *
  6.  * This source file is placed in the public domian.
  7.  * Any resemblance to NCSA Telnet, living or dead, is purely coincidental.
  8.  *
  9.  *      National Center for Supercomputing Applications
  10.  *      152 Computing Applications Building
  11.  *      605 E. Springfield Ave.
  12.  *      Champaign, IL  61820
  13.  */
  14.  
  15. /*
  16.  *
  17.  *    The following calls are implemented
  18.  *
  19.  *        socket
  20.  *        bind
  21.  *        listen
  22.  *        accept
  23.  *        connect
  24.  *        read
  25.  *        recv
  26.  *        recvfrom
  27.  *        write
  28.  *        writev
  29.  *        send
  30.  *        sendto
  31.  *        select
  32.  *        close
  33.  *        getdtablesize
  34.  *        getsockname
  35.  *        getpeername
  36.  *        shutdown
  37.  *        fcntl(F_DUPFD)
  38.  *        fcntl(F_GETFL)
  39.  *        fcntl(F_SETFL,FNDELAY)
  40.  *        dup
  41.  *        dup2
  42.  *        ioctl(FIONBIO)
  43.  *        ioctl(FIONREAD)
  44.  *
  45.  *    Non-blocking I/O is supported. All calls which would block return
  46.  *    immediately with an 'error' indicating so. Select() may be used to
  47.  *    determine when an operation can be performed.
  48.  *
  49.  *    Ioctl(FIONBIO) or fcntl(F_SETFL,FNDELAY)  can be used to toggle or set
  50.  *  the blocking status of a socket.
  51.  *
  52.  *    In a blocking situation, accept() and read() return EWOULDBLOCK and 
  53.  *    refuse to do anything. Select() for read() to learn when a incoming 
  54.  *    connection is available. 
  55.  *
  56.  *    Connect() and write() (which shouldn't take too long anyway) start 
  57.  *    the operation and return EINPROGRESS. Select for write() to learn
  58.  *    when connect() has completed. Write() on a socket which is still
  59.  *    'inprogress' return EALREADY.
  60.  *
  61.  *
  62.  *    Socket operations are single threaded and half-duplex. Fixing this is
  63.  *    left as an execise for the reader. Shouldn't be a terrible problem
  64.  *    anyway. Read() never blocks and write() only blocks for long if there
  65.  *    is a problem.
  66.  *
  67.  *    Calls which find the socket busy will return EALREADY. These are
  68.  *    read() or write() with a connect() or write() in progress.
  69.  *
  70.  *
  71.  *    Socket options are not supported. Hence no setsockopt() and getsockopt() 
  72.  *    calls.
  73.  *
  74.  *
  75.  *  CR: I attempted to support OOB data for send and recv, but not promises are
  76.  *  made as I didn't have any immediate tests for them.
  77.  *
  78.  *
  79.  *    Readv() is not implemented.
  80.  *
  81.  *
  82.  *    All calls which encounter an error will set the global variable errno
  83.  *    to indicate the problem. Some common values for errno are...
  84.  *
  85.  *        EBADF        the socket parameter is not a valid socket descriptor.
  86.  *        
  87.  *        EFAULT       a pointer parameters is rubbish.
  88.  *        
  89.  *        EINVAL       a non-pointer parameters is rubbish.
  90.  *
  91.  *        ENOTCONN     the socket should be in a connected state for this 
  92.  *                   operation, but isn't.
  93.  *
  94.  *        EISCONN      the socket is already connected.
  95.  *
  96.  * ----------------- non-blocking I/O
  97.  *
  98.  *        EWOULDBLOCK  accept() or one of the read() calls would block. 
  99.  *
  100.  *        EINPROGRESS  connect() or one of the write() operations has been 
  101.  *                   started.
  102.  *
  103.  * ----------------- SINGLE THREAD
  104.  *
  105.  *        EALREADY     an operation is already in progress on the socket.
  106.  *
  107.  * ----------------
  108.  *
  109.  *        EBUG           an internal error occured.
  110.  */
  111.  
  112. #ifdef USEDUMP
  113. # pragma load "socket.dump"
  114.  
  115. #else
  116. # include <Events.h>
  117. # include <Types.h>
  118. # include <Stdio.h>
  119.  
  120. # include <s_types.h>
  121. # include <neti_in.h>
  122. #ifdef COMP_CODEWAR
  123. #define NOWAY
  124. #undef EDOM
  125. #undef ERANGE
  126. #endif
  127. # include <neterrno.h>
  128. # include <s_file.h>
  129. # include <s_ioctl.h>
  130. # include <s_socket.h>
  131. # include <s_time.h>
  132. # include <s_uio.h>
  133.  
  134. # include "sock_str.h"
  135. # include "sock_int.h" 
  136.  
  137. #include "unixlib.h"
  138.  
  139. #endif
  140.  
  141. /* #include "sock_ext.h" */
  142.  
  143. #ifdef NOT_NOW_COMP_CODEWAR
  144. #define    EINVAL        22        /* Invalid argument */
  145. #define    EBADF        9        /* Bad file descriptor */
  146. #define    EMFILE        24        /* Too many open files */
  147. #endif
  148.  
  149. /*
  150.  *   GET YOUR GLOBALS HERE!
  151.  */
  152.  
  153. int defaultSpin(spin_msg msg,long param);
  154. SocketPtr sockets = NULL;            /* The socket table. */
  155. AllPb *pbList = NULL;                /* The pb array */
  156. short pbLast = 0;                    /* last pb used */
  157. StreamHashEntPtr streams = NULL;    /* The streams hash table */
  158. SpinFn spinroutine = (SpinFn) defaultSpin;    /* The spin routine. */ 
  159.  
  160. /*
  161.  *    s_socket(domain, type, protocol)
  162.  *
  163.  *        socket creates a MacTCP socket and returns a descriptor.
  164.  *                 
  165.  *        Domain must be AF_INET
  166.  *         
  167.  *        Type may be SOCK_STREAM to create a TCP socket or 
  168.  *        SOCK_DGRAM to create a UDP socket.
  169.  *                 
  170.  *        Protocol is ignored. (isn't it always?)
  171.  *                 
  172.  *        TCP sockets provide sequenced, reliable, two-way connection
  173.  *        based byte streams.
  174.  *
  175.  *        A TCP socket must be in a connected
  176.  *        state before any data may be sent or received on it. A 
  177.  *        connection to another socket is created with a connect() call
  178.  *        or the listen() and accept() calls.
  179.  *        Once connected, data may be transferred using read() and
  180.  *        write() calls or some variant of the send() and recv()
  181.  *        calls. When a session has been completed a close() may  be
  182.  *        performed.
  183.  *
  184.  *        
  185.  *        A UDP socket supports the exchange of datagrams (connectionless, 
  186.  *        unreliable messages of a fixed maximum length) with  
  187.  *        correspondents named in send() calls. Datagrams are
  188.  *        generally received with recv(), which returns the next
  189.  *        datagram with its return address.
  190.  *
  191.  *        An fcntl() or ioctl() call can be used to enable non-blocking I/O.
  192.  *
  193.  *        The return value is a descriptor referencing the socket or -1
  194.  *        if an error occurs, in which case global variable errno is
  195.  *        set to one of:
  196.  *
  197.  *            ENOMEM                Failed to allocate memory for the socket
  198.  *                              data structures.
  199.  *        
  200.  *            EAFNOSUPPORT         Domain wasn't AF_INET.
  201.  *
  202.  *            ESOCKTNOSUPPORT     Type wasn't SOCK_STREAM or SOCK_DGRAM.
  203.  *
  204.  *            EMFILE              The socket descriptor table is full.
  205.  */
  206. int s_socket(
  207.     Int4 domain,
  208.     Int4 type,
  209.     short protocol)
  210. {
  211.     SocketPtr sp;
  212.     int s;
  213.  
  214. #if    SOCK_DEBUG >= 3
  215.     dprintf("s_socket:\n");
  216. #endif
  217.  
  218.     sock_init();
  219.     
  220.     /*
  221.      * Support only Internet family
  222.      */
  223.     if (domain != AF_INET)
  224.         return(sock_err(EAFNOSUPPORT));
  225.         
  226.     switch(type) 
  227.     {
  228.         case SOCK_DGRAM:
  229.             protocol = IPPROTO_UDP;
  230.             break;
  231.         case SOCK_STREAM:
  232.             protocol = IPPROTO_TCP;
  233.             break;
  234.         default:
  235.             return(sock_err(ESOCKTNOSUPPORT));
  236.     }
  237.         
  238.     /*
  239.      *    Create a socket table entry 
  240.      */
  241.     s = sock_free_fd(0);        /* Get next free file descriptor */
  242.     if (s == -1)
  243.         return(sock_err(EMFILE));
  244.     sp = sockets+s;
  245.     sp->fd = s;
  246.     sp->protocol = protocol;
  247.     bzero(&sp->sa, sizeof(struct sockaddr_in));
  248.     bzero(&sp->peer, sizeof(struct sockaddr_in));
  249.     sp->sa.sin_family        = AF_INET;
  250.     sp->sa.sin_len            = sizeof(struct sockaddr_in);
  251.     sp->status                = SOCK_STATUS_USED;
  252.     sp->nonblocking            = false;
  253.  
  254.  
  255.     /* Create a new stream on the socket. */
  256.     switch(sp->protocol) 
  257.     {
  258.         case IPPROTO_UDP:
  259.             /* udp streams are not created until the last minute */
  260.             /* because we dont know if the caller wants to assign */
  261.             /* a special port number yet (via bind) and mactcp */
  262.             /* assigns udp port numbers at stream creation */
  263.             sp->sstate = SOCK_STATE_NO_STREAM;
  264.             break;
  265.  
  266.         case IPPROTO_TCP:
  267.             /* the tcp stream is created now because tcp port numbers */
  268.             /* are assigned during active/passiveOpen which is done */
  269.             /* during listen or connect */
  270.             sp->sstate = SOCK_STATE_UNCONNECTED;
  271.             if (sock_tcp_new_stream(sp) < 0)
  272.                 return(-1); /* sock_err already called */
  273.     }
  274.  
  275.     return(s);
  276. }
  277.  
  278.  
  279. /*
  280.  *    s_bind(s, name, namelen)
  281.  *
  282.  *        bind requests that the name (ip address and port) pointed to by 
  283.  *        name be assigned to the socket s.
  284.  *        
  285.  *        The return value is 0 on success or -1 if an error occurs,
  286.  *        in which case global variable errno is set to one of:
  287.  *
  288.  *        EAFNOSUPPORT        The address family in name is not AF_INET.
  289.  *        
  290.  *        EINVAL              The socket is already bound to an address.
  291.  *        
  292.  *        EADDRNOTAVAIL       The specified address is  not  available
  293.  *                             from the local machine. ie. the address
  294.  *                            portion of name was not this machine's address.
  295.  *
  296.  *        MacTCP does not separate name binding and connection establishment.
  297.  *        Therefore the port number is not verified, just stored for later use.
  298.  *
  299.  *        If a specific local port is not required, bind is optional in this
  300.  *        implementation.
  301.  */    
  302. int s_bind( 
  303.     Int4 s, 
  304.     struct sockaddr *sa_name,
  305.     Int4 namelen)
  306. {
  307.     SocketPtr sp;
  308.     struct sockaddr_in *name=(struct sockaddr_in *)sa_name;
  309.     
  310. #if    SOCK_DEBUG >= 3
  311.     dprintf("s_bind: bind %d to %08x/%d\n",
  312.         s, name->sin_addr.s_addr, name->sin_port);
  313. #endif
  314.  
  315.     if (! sock_good_fd(s))
  316.         return(sock_err(EBADF));
  317.     sp = sockets+s;
  318.         
  319.     if (namelen < sizeof(struct sockaddr_in))
  320.         return(sock_err(EINVAL));
  321.  
  322.     if (!goodptr(name)) 
  323.         return(sock_err(EFAULT));
  324.  
  325.     if (name->sin_family != AF_INET)
  326.         return(sock_err(EAFNOSUPPORT));
  327.  
  328.     if (sp->sa.sin_port != 0) /* already bound */
  329.         return(sock_err(EINVAL));
  330.  
  331.     /*
  332.      *    If client passed a local IP address, assure it is the right one
  333.      */
  334.     if (name->sin_addr.s_addr != 0) 
  335.     {
  336.         if (name->sin_addr.s_addr != xIPAddr())
  337.             return(sock_err(EADDRNOTAVAIL));
  338.     }
  339.  
  340.     /*
  341.      *    NOTE: can't check a TCP port for EADDRINUSE
  342.      *    just save the address and port away for connect or listen or...
  343.      */
  344.     sp->sa.sin_addr.s_addr = name->sin_addr.s_addr;
  345.     sp->sa.sin_port = name->sin_port;
  346.     return(0);
  347. }
  348.  
  349. /*
  350.  *    s_connect - initiate a connection on a MacTCP socket
  351.  *
  352.  *        If the parameter s is a UDP socket,
  353.  *        then  this  call specifies the address to  which  datagrams
  354.  *        are  to  be  sent, and the only address from which datagrams
  355.  *        are to be received.  
  356.  *             
  357.  *        If it is a TCP socket, then this call attempts to make a 
  358.  *        connection to another socket. The other socket is specified 
  359.  *        by an internet address and port.
  360.  *             
  361.  *        TCP sockets may successfully connect() only once;
  362.  *             
  363.  *        UDP sockets may use connect() multiple times to change
  364.  *        their association. UDP sockets may dissolve the association
  365.  *        by connecting to an invalid address, such as a null
  366.  *        address.
  367.  *        
  368.  *        If the connection or binding succeeds, then 0 is returned.
  369.  *        Otherwise a -1 is returned, and a more specific error code
  370.  *        is stored in errno.
  371.  *        
  372.  *        EAFNOSUPPORT        The address family in addr is not AF_INET.
  373.  *        
  374.  *        EHOSTUNREACH        The TCP connection came up half-way and 
  375.  *                          then failed.
  376.  *             
  377.  *    -------------- some day instead of EHOSTUNREACH -----------------
  378.  *        
  379.  *        EADDRNOTAVAIL       The specified address is not available
  380.  *                            on the remote machine.
  381.  *        
  382.  *        ETIMEDOUT           Connection establishment timed out
  383.  *                            without establishing a connection.
  384.  *        
  385.  *        ECONNREFUSED        The attempt to  connect  was  forcefully
  386.  *                            rejected.
  387.  *        
  388.  *        ENETUNREACH         The network is not reachable from here.
  389.  *        
  390.  *        EHOSTUNREACH        The host is not reachable from here.
  391.  *        
  392.  *        EADDRINUSE          The address is already in use.
  393.  */
  394. int s_connect(
  395.     Int4 s,
  396.     struct sockaddr *sa_addr,
  397.     Int4 addrlen)
  398. {
  399.     SocketPtr sp;
  400.     struct sockaddr_in *addr=(struct sockaddr_in *)sa_addr;
  401.     
  402. #if SOCK_DEBUG >= 2
  403.     dprintf("s_connect: connect %d to %08x/%d\n",
  404.         s, addr->sin_addr.s_addr, addr->sin_port);
  405. #endif
  406.     if (! sock_good_fd(s))
  407.         return(sock_err(EBADF));
  408.         
  409.     if (addrlen != sizeof(struct sockaddr_in))
  410.         return(sock_err(EINVAL));
  411.  
  412.     if (! goodptr(addr))
  413.         return(sock_err(EFAULT));
  414.  
  415.     if (addr->sin_family != AF_INET)
  416.         return(sock_err(EAFNOSUPPORT));
  417.  
  418.     sp = sockets+s;
  419.     switch(sp->protocol) 
  420.     {
  421.         case IPPROTO_UDP:
  422.             return(sock_udp_connect(sp,addr));
  423.  
  424.         case IPPROTO_TCP:
  425.             return(sock_tcp_connect(sp,addr));
  426.     }
  427.     return(0);
  428. }
  429.  
  430. /*
  431.  *    s_listen()
  432.  *
  433.  *        To accept connections, a socket is first created  with
  434.  *        socket(), a backlog for incoming connections is specified
  435.  *        with listen() and then the  connections  are  accepted  with
  436.  *        accept(). The listen() call applies only to TCP sockets.
  437.  *        
  438.  *        The qlen parameter is supposed to define the maximum length
  439.  *        the queue of pending connections may grow to. It is ignored.
  440.  *        
  441.  *        A 0 return value indicates success; -1 indicates an error.
  442.  *        
  443.  *        EOPNOTSUPP          s is not a TCP socket.
  444.  */
  445. int s_listen(
  446.     Int4 s,
  447.     Int4 qlen)
  448. {
  449. #pragma unused(qlen)
  450.     SocketPtr sp;
  451.     
  452. #if SOCK_DEBUG >= 2
  453.     dprintf("listen: listen %d\n", s);
  454. #endif
  455.     if (! sock_good_fd(s))
  456.         return(sock_err(EBADF));
  457.         
  458.     sp = sockets+s;    
  459.     switch(sp->protocol) 
  460.     {
  461.         case IPPROTO_UDP:
  462.             return(sock_err(EOPNOTSUPP));
  463.         
  464.         case IPPROTO_TCP:
  465.             return(sock_tcp_listen(sp));
  466.     }
  467.     return(0);
  468.  
  469. }
  470.  
  471. /*
  472.  *    s_accept(s, addr, addrlen)
  473.  *
  474.  *        s is a socket that has been created with socket,  bind, listen.
  475.  *        
  476.  *        Accept  extracts the  first  connection  on the queue of pending 
  477.  *        connections, creates a new socket with the same properties of s 
  478.  *        and allocates  a  new  file  descriptor,  ns, for the socket.
  479.  *        
  480.  *        If no pending connections are present on the queue, and the socket
  481.  *        is not marked as non-blocking, accept blocks the caller until
  482.  *        a connection is present. 
  483.  *        
  484.  *        If the socket is marked non-blocking  and  no pending connections 
  485.  *        are present on the queue, accept returns an error EWOULDBLOCK.
  486.  *        
  487.  *        The accepted socket, ns, is used to read and write data to and
  488.  *        from the socket which connected to this one; it is not  used
  489.  *        to  accept  more connections.  The original socket s remains
  490.  *        open for accepting further connections.
  491.  *        
  492.  *        The argument addr is a result parameter that  is  filled  in
  493.  *        with  the  address of the connecting socket. The addrlen is 
  494.  *        a value-result  parameter; it should initially contain the
  495.  *        amount of space pointed to by addr; on return it will contain 
  496.  *        the actual length (in bytes) of the address returned.
  497.  *        
  498.  *        This call is used with TCP sockets only.
  499.  *        
  500.  *        It is possible to select a socket  for  the  purposes  of
  501.  *        doing an accept by selecting it for read.
  502.  *
  503.  *        Translation: To check and see if there is a connection pending,
  504.  *        call s_select and check for pending reads.
  505.  *        
  506.  *        The call returns -1 on error.  If it succeeds, it returns  a
  507.  *        non-negative  integer  that is a descriptor for the accepted
  508.  *        socket.
  509.  *        
  510.  *        EOPNOTSUPP          s is not a TCP socket.
  511.  *        
  512.  *        EMFILE              The socket descriptor table is full.
  513.  */
  514. int s_accept(
  515.     Int4 s,
  516.     struct sockaddr *sa_addr,
  517.     Int4 *addrlen)
  518. {
  519.     SocketPtr sp;
  520.     struct sockaddr_in *addr=(struct sockaddr_in *)sa_addr;
  521.  
  522. #if SOCK_DEBUG >= 2
  523.     dprintf("s_accept: %d\n", s);
  524. #endif
  525.     if (! sock_good_fd(s))
  526.         return(sock_err(EBADF));
  527.         
  528.     if (!goodptr(addr) || !goodptr(addrlen)) 
  529.         return(sock_err(EFAULT));
  530.  
  531.     if (*addrlen < 0) 
  532.         return(sock_err(EINVAL));
  533.  
  534.     if (sock_free_fd(0) == -1)
  535.         return(sock_err(EMFILE));
  536.  
  537.     sp = sockets+s;
  538.     switch(sp->protocol) 
  539.     {
  540.         case IPPROTO_UDP:
  541.             return(sock_err(EOPNOTSUPP));
  542.         case IPPROTO_TCP:
  543.             return(sock_tcp_accept(sp,addr,addrlen));
  544.     }
  545.     return(sock_err(EFAULT));
  546. }
  547.  
  548. /*
  549.  * s_accept_once
  550.  *
  551.  * A mac specific routine, designed to compenstate for a bug
  552.  * in MacTCP. If you close a passive, unconnected stream,
  553.  * MacTCP will generate an error. s_accept always creates
  554.  * a new listening (passive open) stream that will eventually
  555.  * need to be closed. s_accept_once does not create a new
  556.  * listening socket. It will return the same socket originally
  557.  * passed to it, and NO more connections will be accepted
  558.  * on the old listening port.
  559.  *
  560.  * Other than that, it is identical to s_accept.
  561.  */
  562. int s_accept_once(
  563.     Int4 s,
  564.     struct sockaddr *sa_addr,
  565.     Int4 *addrlen)
  566. {
  567.     SocketPtr sp;
  568.     struct sockaddr_in *addr=(struct sockaddr_in *)sa_addr;
  569.  
  570. #if SOCK_DEBUG >= 2
  571.     dprintf("s_accept: %d\n", s);
  572. #endif
  573.     if (! sock_good_fd(s))
  574.         return(sock_err(EBADF));
  575.         
  576.     if (!goodptr(addr) || !goodptr(addrlen)) 
  577.         return(sock_err(EFAULT));
  578.  
  579.     if (*addrlen < 0) 
  580.         return(sock_err(EINVAL));
  581.  
  582.     if (sock_free_fd(0) == -1)
  583.         return(sock_err(EMFILE));
  584.  
  585.     sp = sockets+s;
  586.     switch(sp->protocol) 
  587.     {
  588.         case IPPROTO_UDP:
  589.             return(sock_err(EOPNOTSUPP));
  590.         case IPPROTO_TCP:
  591.             {
  592.             int        returnCode;
  593.             
  594.             returnCode=sock_tcp_accept_once(sp,addr,addrlen);
  595.             return (returnCode ? returnCode : s );
  596.             }
  597.     }
  598.     return(sock_err(EFAULT));
  599. }
  600.  
  601. /*
  602.  *    s_close(s)
  603.  *
  604.  *        The close call destroys the socket s. If this is the last reference 
  605.  *        to the underlying MacTCP stream, then the stream will be released.
  606.  *    
  607.  *        A 0 return value indicates success; -1 indicates an error.
  608.  *
  609.  *        NOTE: if non-blocking I/O is enabled EWOULDBLOCK will be returned
  610.  *            if there are TCP writes in progress. (UDP writes are
  611.  *            performed synchronously.)
  612.  *
  613.  *              All reads are terminated and unread data is lost.
  614.  */
  615. int s_close(
  616.     Int4 s)
  617. {
  618.     int t;
  619.     SocketPtr sp;
  620.     int status;
  621.     
  622. #if SOCK_DEBUG >= 2
  623.     dprintf("s_close: %d\n", s);
  624. #endif
  625.     if (! sock_good_fd(s))
  626.         return(sock_err(EBADF));
  627.         
  628.     sp = sockets+s;
  629.  
  630.     /*
  631.      *    Look for duplicates of the socket.  Only close down the connection
  632.      *    if there are no duplicates(i.e. socket not dup'd).
  633.      */
  634.      for (t = 0; t < NUM_SOCKETS; t++) 
  635.      {
  636.          if (t == s)
  637.             continue;
  638.          if (!(sockets[t].status & SOCK_STATUS_USED))
  639.             continue;
  640.         else if (sockets[t].protocol == sp->protocol && sockets[t].stream == sp->stream )
  641.         {    /* found a duplicate */
  642. #if SOCK_DEBUG >= 3
  643.             dprintf("s_close: found a dup at %d(%d, don't close stream\n",
  644.                 t, sockets[t].protocol);
  645. #endif
  646.             sock_clear_fd(s);
  647.             return(0);
  648.         }
  649.     }
  650.  
  651.     /*
  652.      *    No duplicates, close the stream. 
  653.      */
  654.     switch(sp->protocol) 
  655.     {
  656.         case IPPROTO_UDP:
  657.             status = sock_udp_close(sp);
  658.             break;
  659.             
  660.         case IPPROTO_TCP:
  661.             status = sock_tcp_close(sp);
  662.             break;
  663.     }
  664.     if (status != EWOULDBLOCK)
  665.         sock_clear_fd(s);
  666.     return(status);
  667. }
  668.  
  669.  
  670. /*
  671.  *    s_read(s, buffer, buflen)
  672.  *
  673.  *    s_recv(s, buffer, buflen, flags)
  674.  *    
  675.  *    s_recvfrom(s, buffer, buflen, flags, from, fromlen)
  676.  *    
  677.  *        read() attempts to read nbytes of data from the socket s.  
  678.  *        
  679.  *        recv() and recvfrom() attempt to receive a message (ie a datagram) 
  680.  *        on the socket s. 
  681.  *
  682.  *        from returns the address of the socket which sent the message.
  683.  *        fromlen is the usual value-result length parameter. 
  684.  *        
  685.  *        Typically, read() is used with a TCP stream and recv() with
  686.  *        UDP where the idea of a message makes more sense. But in fact,
  687.  *        read() and recv() are equivalent.
  688.  *        
  689.  *        For UDP...
  690.  *            If a message (ie. datagram) is too long to fit in the supplied 
  691.  *            buffer, excess bytes will be discarded..
  692.  *
  693.  *            If no messages are available at the socket, the receive call
  694.  *            waits for a message to arrive, unless the socket is non-
  695.  *            blocking in which case -1 is returned with errno set to 
  696.  *            EWOULDBLOCK.
  697.  *
  698.  *        For TCP...
  699.  *            Regardless of non-blocking status, if less data is available
  700.  *            than has been requested, only that much data is returned.
  701.  *
  702.  *            If the socket is marked for non-blocking I/O, and the socket 
  703.  *            is empty, the operation will fail with the error EWOULDBLOCK.
  704.  *            Otherwise, the operation will block until data is available 
  705.  *            or an error occurs.
  706.  *
  707.  *            A return value of zero indicates that the stream has been
  708.  *            closed and all data has already been read. ie. end-of-file.
  709.  *        
  710.  *        Flags is ignored.
  711.  *        
  712.  *        If successful, the number of bytes actually received is
  713.  *        returned. Otherwise, a -1 is returned and the global variable
  714.  *        errno is set to indicate the error. 
  715.  *        
  716.  *        ESHUTDOWN    The socket has been shutdown for receive operations.
  717.  */
  718.  
  719. int s_recvfrom(Int4 s, void *buffer, Int4 buflen, Int4 flags, 
  720.                 struct sockaddr *sa_from, Int4 *fromlen);
  721.  
  722.  
  723. int s_read(
  724.     Int4 s,
  725.     void *buffer,
  726.     Int4 buflen)
  727. {
  728.     Int4 fromlen = 0;
  729.     return(s_recvfrom(s, buffer, buflen, 0, NULL, &fromlen));
  730. }
  731.  
  732. int s_recv(
  733.     Int4 s,
  734.     void *buffer,
  735.     Int4 buflen,
  736.     Int4 flags)
  737. {
  738.     Int4 fromlen = 0;
  739.     return(s_recvfrom(s, buffer, buflen, flags, NULL, &fromlen));
  740. }
  741.  
  742. int s_recvfrom(
  743.     Int4 s,
  744.     void *buffer,
  745.     Int4 buflen,
  746.     Int4 flags,
  747.     struct sockaddr *sa_from,
  748.     Int4 *fromlen)
  749. {
  750.     SocketPtr sp;
  751.     struct sockaddr_in *from=(struct sockaddr_in *)sa_from;
  752.  
  753. #if SOCK_DEBUG >= 3
  754.     dprintf ("s_recvfrom: %d\n", s);
  755. #endif
  756.     if (s < 0 || s >= NUM_SOCKETS)
  757.         return (sock_err (EBADF));
  758.         
  759.     sp = sockets+s;
  760.     if (! is_used (sp))
  761.         return (sock_err (EBADF));
  762.         
  763.     if (!goodptr(buffer))
  764.         return (sock_err (EFAULT));
  765.         
  766.     if (buflen <= 0)
  767.         return(sock_err(EINVAL));
  768.         
  769.     if (! (from == NULL || goodptr(from)) )
  770.         return(sock_err(EFAULT));
  771.         
  772.     if (! (fromlen == NULL || goodptr(fromlen)) )
  773.         return(sock_err(EFAULT));
  774.     else
  775.         if ( *fromlen < 0 )
  776.             return(sock_err(EINVAL));
  777.  
  778.     if (sock_noread(sp))
  779.         return(sock_err(ESHUTDOWN));
  780.  
  781.     switch(sp->protocol) 
  782.     {
  783.         case IPPROTO_UDP:
  784.             return(sock_udp_recv(sp,(char*) buffer, buflen, flags, from, (int *)fromlen));
  785.  
  786.         case IPPROTO_TCP:
  787.             return(sock_tcp_recv(sp,(char*)  buffer, buflen, flags));
  788.     }
  789.     return(sock_err(EFAULT));
  790. }
  791.  
  792.  
  793. /*
  794.  *    s_write(s, buffer, buflen)
  795.  *
  796.  *    s_writev(s, iov, iovcnt)
  797.  *
  798.  *    s_send(s, buffer, buflen, flags)
  799.  *
  800.  *    s_sendto(s, buffer, buflen, flags, to, tolen)
  801.  *
  802.  *        write() attempts to write nbytes of data to the socket s from
  803.  *        the buffer pointed to by buffer.
  804.  *        
  805.  *        writev() gathers the output data from the buffers specified 
  806.  *        by the members of the iov array. Each iovec entry specifies 
  807.  *        the base address and length of an area in memory from which 
  808.  *        data should be written.
  809.  *        
  810.  *        send() and sendto() are used to transmit a message to another 
  811.  *        socket on the socket s.
  812.  *
  813.  *        Typically, write() is used with a TCP stream and send() with
  814.  *        UDP where the idea of a message makes more sense. But in fact,
  815.  *        write() and send() are equivalent.
  816.  *        
  817.  *        For UDP...
  818.  *
  819.  *          Write() and send() operations are completed as soon as the
  820.  *          data is placed on the transmission queue.???????
  821.  *
  822.  *            The address of the target is given by to.
  823.  *
  824.  *            The message must be short enough to fit into one datagram.
  825.  *        
  826.  *            Buffer space must be available to hold the message to be 
  827.  *            transmitted, regardless of its non-blocking I/O state.
  828.  *        
  829.  *        For TCP...
  830.  *            Write() and send() operations are not considered complete
  831.  *            until all data has been sent and acknowledged.
  832.  *
  833.  *            If a socket is marked for non-blocking I/O, the operation
  834.  *            will return an 'error' of EINPROGRESS.
  835.  *        
  836.  *            If the socket is not marked for non-blocking I/O, the write will
  837.  *            block until space becomes available.
  838.  *        
  839.  *        write() and send() may be used only when the socket is in a connected
  840.  *        state, sendto() may be used at any time.
  841.  *
  842.  *        Flags is ignored.
  843.  *        
  844.  *        These calls return the number of bytes sent, or -1 if an error 
  845.  *        occurred.
  846.  *        
  847.  *        EINVAL           The sum of the iov_len values in the iov array was
  848.  *                         greater than 65535 (TCP) or 65507 (UDP) or there
  849.  *                       were too many entries in the array (16 for TCP or
  850.  *                       6 for UDP).
  851.  *
  852.  *        ESHUTDOWN        The socket has been shutdown for send operations.
  853.  *        
  854.  *        EMSGSIZE         The message is too big to send in one datagram. (UDP)
  855.  *
  856.  *        ENOBUFS          The transmit queue is full. (UDP)
  857.  */
  858.  
  859.  
  860. int s_really_send(
  861.     Int4 s,
  862.     void *buffer,
  863.     Int4 count,
  864.     Int4 flags,
  865.     struct sockaddr_in *to);
  866.     
  867.     
  868. int s_write(
  869.     Int4 s,
  870.     void *buffer,
  871.     Int4 buflen)
  872. {
  873.     return(s_really_send(s, buffer, buflen, 0, NULL));
  874. } 
  875.  
  876. int s_writev(
  877.     Int4 s,
  878.     struct iovec *iov,
  879.     Int4 count)
  880. {    
  881.     int        result,tally=0;
  882.     
  883.     while (count--)
  884.         {
  885.         if ( !goodptr( iov ) )
  886.             return sock_err(EFAULT);
  887.         result= s_really_send(s, (char *)(iov->iov_base),
  888.                 (int)(iov->iov_len), 0, NULL);
  889.         if (result < 0)
  890.             return sock_err(result);
  891.         iov++;
  892.         tally+=result;
  893.         }
  894.     return tally;
  895. } 
  896.  
  897. int s_send(
  898.     Int4 s,
  899.     void *buffer,
  900.     Int4 buflen,
  901.     Int4 flags)
  902. {
  903.     return(s_really_send(s, buffer, buflen, flags, NULL));
  904. } 
  905.  
  906. int s_sendto (
  907.     Int4 s,
  908.     void *buffer,
  909.     Int4 buflen,
  910.     Int4 flags,
  911.     struct sockaddr *sa_to,
  912.     Int4 tolen)
  913. {
  914.     SocketPtr sp;
  915.     struct sockaddr_in *to=(struct sockaddr_in *)sa_to;
  916.  
  917.     if (s < 0 || s >= NUM_SOCKETS)
  918.         return (sock_err (EBADF));
  919.         
  920.     sp = sockets+s;
  921.     
  922.     if (! is_used (sp))
  923.         return (sock_err (EBADF));
  924.         
  925.     if (!goodptr(buffer))
  926.         return (sock_err (EFAULT));
  927.         
  928.     if (buflen <= 0)
  929.         return(sock_err(EINVAL));
  930.         
  931.     if (to != NULL && !goodptr(to))
  932.         return(sock_err(EFAULT));
  933.         
  934.     if (to != NULL && tolen < sizeof(struct sockaddr_in))
  935.         return(sock_err(EINVAL));
  936.  
  937.     return(s_really_send(s, buffer, buflen, flags, to));
  938. }
  939.  
  940. int s_sendmsg(Int4 s,struct msghdr *msg,Int4 flags) {
  941.     SocketPtr sp;
  942.     struct iovec *iov=NULL;
  943.     int tally=0,result,count;
  944.  
  945.     if (s < 0 || s >= NUM_SOCKETS)
  946.         return (sock_err (EBADF));
  947.         
  948.     sp = sockets+s;
  949.     
  950.     if (! is_used (sp))
  951.         return (sock_err (EBADF));
  952.     if (!goodptr(msg))
  953.         return (sock_err (EFAULT));
  954.     if ( msg->msg_name != NULL && !goodptr(msg->msg_name) ) 
  955.         return (sock_err (EFAULT));
  956.     if ( msg->msg_name != NULL && msg->msg_namelen < sizeof (struct sockaddr_in))
  957.         return (sock_err (EFAULT));
  958.     
  959.     count = msg->msg_iovlen;
  960.     iov = msg->msg_iov;
  961.     while ( count -- ) {
  962.         if ( !goodptr( iov ) )
  963.             return sock_err(EFAULT);
  964.         result= s_really_send(s, (char *)(iov->iov_base),
  965.                 (int)(iov->iov_len), flags,(struct sockaddr_in *)msg->msg_name);
  966.         if (result < 0)
  967.             return (sock_err(result));
  968.         iov++;
  969.         tally+=result;
  970.         }
  971.     return tally;
  972.     }
  973.  
  974. int s_really_send(
  975.     Int4 s,
  976.     void *buffer,
  977.     Int4 count,
  978.     Int4 flags,
  979.     struct sockaddr_in *to)
  980.     
  981.     {
  982.     SocketPtr    sp;
  983.     int            tally=0;
  984.  
  985. #if SOCK_DEBUG >= 2
  986.     dprintf("s_really_send: %d  %d bytes", s, count);
  987.     if (to != NULL)
  988.         dprintf(" to %08x/%d",to->sin_addr.s_addr,to->sin_port);
  989.     dprintf("\n");
  990. #endif
  991.     if (! sock_good_fd(s))
  992.         return(sock_err(EBADF));
  993.     sp = sockets+s;
  994.  
  995. #if SOCK_DEBUG >= 2
  996.     dprintf("state %d\n",sp->sstate);
  997.     dprintf("peer %08x/%d\n",sp->peer.sin_addr.s_addr,sp->peer.sin_port);
  998. #endif
  999.     
  1000.     if (sock_nowrite(sp))
  1001.         return(sock_err(ESHUTDOWN));
  1002.  
  1003.     switch(sp->protocol) 
  1004.         {
  1005.         case IPPROTO_UDP:
  1006.             if (to == NULL && sp->sstate != SOCK_STATE_CONNECTED) 
  1007.                 return(sock_err(ENOTCONN));
  1008.             return(sock_udp_send(sp, to,(char*)  buffer, count, flags));
  1009.             break;
  1010.             
  1011.         case IPPROTO_TCP:
  1012.             if (to != NULL) /* sendto */
  1013.                 return(sock_err(EOPNOTSUPP));
  1014.             if (sp->sstate != SOCK_STATE_CONNECTED) 
  1015.                 return(sock_err(ENOTCONN));
  1016.             return ( sock_tcp_send(sp, (char*) buffer, count,0 ));
  1017.             break;
  1018.         }
  1019.     return(sock_err(ESHUTDOWN));
  1020.     }
  1021.  
  1022.  
  1023. /*
  1024.  *    s_select(width, readfds, writefds, exceptfds, timeout)
  1025.  *
  1026.  *        select() examines the I/O descriptor  sets  whose  addresses
  1027.  *        are  passed  in  readfds,  writefds, and exceptfds to see if
  1028.  *        some of their descriptors are ready for reading,  ready  for
  1029.  *        writing, or have an exceptional condition pending.  width is
  1030.  *        the number of bits to be  checked  in  each  bit  mask  that
  1031.  *        represent  a file descriptor; the descriptors from 0 through
  1032.  *        width-1 in the  descriptor  sets  are  examined.   Typically
  1033.  *        width  has  the  value  returned by getdtablesize for the
  1034.  *        maximum number of file  descriptors.   On  return,  select
  1035.  *        replaces  the  given descriptor sets with subsets consisting
  1036.  *        of those descriptors that are ready for the requested opera-
  1037.  *        tion.  The total number of ready descriptors in all the sets
  1038.  *        is returned.
  1039.  *
  1040.  *        If timeout is not a NULL pointer,  it  specifies  a  maximum
  1041.  *        interval  to wait for the selection to complete.  If timeout
  1042.  *        is a NULL  pointer,  the  select  blocks  indefinitely.   To
  1043.  *        effect  a  poll,  the  timeout argument should be a non-NULL
  1044.  *        pointer, pointing to a zero-valued timeval structure.
  1045.  *
  1046.  *        Any of readfds, writefds, and exceptfds may be given as NULL
  1047.  *        pointers if no descriptors are of interest.
  1048.  *
  1049.  *        Using select to open a socket for reading is analogous  to
  1050.  *        performing an accept call.
  1051.  *
  1052.  *        select() returns the number of ready  descriptors  that  are
  1053.  *        contained  in  the  descriptor  sets,  or  -1  if  an  error
  1054.  *        occurred.  If the time limit expires then  select()  returns
  1055.  *        0.   If select() returns with an error the descriptor sets 
  1056.  *      will be unmodified.
  1057.  */
  1058. int s_select(
  1059.     Int4 width,
  1060.     fd_set *readfds,
  1061.     fd_set *writefds,
  1062.     fd_set *exceptfds,
  1063.     struct timeval *timeout)
  1064. {
  1065.     SocketPtr sp;
  1066.     long count;
  1067.     int s;
  1068.     long starttime, waittime;
  1069.     fd_set rd, wd, ed;
  1070.     int errorHappened;
  1071.  
  1072. #if SOCK_DEBUG >= 2
  1073.     dprintf("select:  socket: width %d\n",width);
  1074. #endif
  1075.     if (!goodptr(timeout) && timeout != NULL)
  1076.         return(sock_err(EFAULT));
  1077.     if (!goodptr(readfds) && readfds != NULL)
  1078.         return(sock_err(EFAULT));
  1079.     if (!goodptr(writefds) && writefds != NULL)
  1080.         return(sock_err(EFAULT));
  1081.     if (!goodptr(exceptfds) && exceptfds != NULL)
  1082.         return(sock_err(EFAULT));
  1083.         
  1084. #if SOCK_DEBUG >= 3
  1085.     dprintf("select: timeout %d sec, read %08x write %08x except %08x\n",
  1086.         (timeout ? timeout->tv_sec : 99999), 
  1087.         (readfds!=NULL ? *readfds : 0L),
  1088.         (writefds!=NULL ? *writefds : 0L),
  1089.         (exceptfds!=NULL ? *exceptfds : 0L));
  1090. #endif
  1091.  
  1092.     if (width > NUM_SOCKETS)    /* for now..xxx. */
  1093.         width = NUM_SOCKETS;
  1094.     count = 0;
  1095.     FD_ZERO(&rd);
  1096.     FD_ZERO(&wd);
  1097.     FD_ZERO(&ed);
  1098.  
  1099.     if (timeout) 
  1100.     {
  1101.         waittime = TVTOTICK(timeout->tv_sec,timeout->tv_usec);
  1102.         starttime = TickCount();
  1103.     }
  1104. #if SOCK_DEBUG >= 5
  1105.     dprintf("     starttime = %d(tics);  waittime = %d\n",starttime, waittime);
  1106. #endif
  1107.  
  1108.     do 
  1109.     {
  1110.         for (s = 0 , sp = sockets ; s < width ; ++s, ++sp) 
  1111.         {
  1112.             if (is_used(sp)) 
  1113.             {
  1114.                 errorHappened = 0;
  1115.                 
  1116.                 /* Check if there is data or connection available. */
  1117.                 if (readfds && FD_ISSET(s,readfds)) 
  1118.                 {
  1119.                         
  1120.                     switch(sp->protocol) 
  1121.                     {
  1122.                         case IPPROTO_UDP:
  1123.                             switch (sock_udp_can_recv(sp))
  1124.                             {
  1125.                                 case 1:
  1126.                                     FD_SET(s,&rd);
  1127.                                     ++count;
  1128.                                     break;
  1129.                                 case -1:
  1130.                                     errorHappened = 1;
  1131.                                     break;
  1132.                             }
  1133.                             break;
  1134.                 
  1135.                         case IPPROTO_TCP:
  1136.                     /* Must exit if stream is dead to avoid eternal lock up */
  1137.                             if (sock_tcp_can_read(sp) ) {
  1138.                                 FD_SET(s,&rd);
  1139.                                 ++count;
  1140.                                 } 
  1141.                             break;
  1142.                     }
  1143.                 }
  1144.                 if (writefds && FD_ISSET(s,writefds)) 
  1145.                 {
  1146.                     switch(sp->protocol) 
  1147.                     {
  1148.                         case IPPROTO_UDP:
  1149.                             switch (sock_udp_can_send(sp))
  1150.                             {
  1151.                                 case 1:
  1152.                                     FD_SET(s,&wd);
  1153.                                     ++count;
  1154.                                     break;
  1155.                                 case -1:
  1156.                                     errorHappened = 1;
  1157.                                     break;
  1158.                             }
  1159.                             break;
  1160.                 
  1161.                         case IPPROTO_TCP:
  1162.                             if (sock_tcp_can_write(sp))
  1163.                             {
  1164.                                 FD_SET(s,&wd);
  1165.                                 ++count;
  1166.                             }
  1167.                             break;
  1168.                     }
  1169.                 }
  1170.                 if (exceptfds && FD_ISSET(s,exceptfds)) 
  1171.                 {
  1172.                     if (errorHappened)  
  1173.                     {
  1174.                         FD_SET(s,&ed);
  1175.                         ++count;
  1176.                     }
  1177.                 }
  1178.             }
  1179.         }
  1180.         SPIN(false,SP_SELECT,0L)
  1181.     } 
  1182.     while(count == 0 &&(timeout == 0 || TickCount() - starttime < waittime));
  1183.  
  1184.     if (readfds)             
  1185.         *readfds = rd;
  1186.     if (writefds)             
  1187.         *writefds = wd;
  1188.     if (exceptfds)             
  1189.         *exceptfds = ed;
  1190. #if SOCK_DEBUG >= 5
  1191.     dprintf("     elapsed = %d(tics)  count %d, read %08x write %08x except %08x\n",
  1192.         TickCount()-starttime,count,
  1193.         (readfds!=NULL ? *readfds : 0L),
  1194.         (writefds!=NULL ? *writefds : 0L),
  1195.         (exceptfds!=NULL ? *exceptfds : 0L));
  1196. #endif
  1197.     return(count);
  1198. }
  1199.     
  1200. /*
  1201.  *    s_getdtablesize()
  1202.  *
  1203.  *        The entries in the socket descriptor table are numbered with small
  1204.  *        integers starting at 0. getdtablesize returns the size of the 
  1205.  *        descriptor table.
  1206.  */
  1207. int s_getdtablesize()
  1208. {
  1209.     return(NUM_SOCKETS);
  1210. }
  1211.  
  1212. /*
  1213.  *    s_getsockname(s, name, namelen)
  1214.  *
  1215.  *        getsockname returns the current name for the  socket s.
  1216.  *        Namelen should  be initialized to
  1217.  *        indicate the amount of space pointed to by name.  On  return
  1218.  *        it contains the actual size of the name returned (in bytes).
  1219.  *        
  1220.  *        A 0 is returned if the call succeeds, -1 if it fails.
  1221.  */
  1222.  
  1223. int s_getsockname(
  1224.     Int4 s,
  1225.     struct sockaddr *name,
  1226.     Int4 *namelen)
  1227. {
  1228. #if SOCK_DEBUG >= 3
  1229.     dprintf("GETSOCKNAME: %d\n", s);
  1230. #endif
  1231.     if (! sock_good_fd(s))
  1232.         return(sock_err(EBADF));
  1233.  
  1234.     if (! goodptr(name))
  1235.         return(sock_err(EFAULT));
  1236.         
  1237.     if (*namelen < 0)
  1238.         return(sock_err(EINVAL));
  1239.  
  1240.     sock_copy_addr(&sockets[s].sa, name, namelen);
  1241.     return(0);
  1242. }
  1243.  
  1244. /*
  1245.  *    s_getpeername(s, name, namelen)
  1246.  *
  1247.  *        getpeername returns the name of the peer connected to socket s.
  1248.  *
  1249.  *        The  int  pointed  to  by the namelen parameter
  1250.  *        should be  initialized  to  indicate  the  amount  of  space
  1251.  *        pointed  to  by name.  On return it contains the actual size
  1252.  *        of the name returned (in bytes).  The name is  truncated  if
  1253.  *        the buffer provided is too small.
  1254.  *        
  1255.  *        A 0 is returned if the call succeeds, -1 if it fails.
  1256.  */
  1257. int s_getpeername(
  1258.     Int4 s,
  1259.     struct sockaddr *name,
  1260.     Int4 *namelen)
  1261. {
  1262.     SocketPtr sp;
  1263.  
  1264. #if SOCK_DEBUG >= 2
  1265.     dprintf("getpeername: socket %d\n", s);
  1266. #endif
  1267.     if (! sock_good_fd(s))
  1268.         return(sock_err(EBADF));        
  1269.  
  1270.     sp = sockets+s;
  1271.     if (! is_used (sp))
  1272.         return (sock_err (EBADF));
  1273.  
  1274.     if (! goodptr(name))
  1275.         return(sock_err(EFAULT));
  1276.         
  1277.     if (*namelen < 0)
  1278.         return(sock_err(EINVAL));
  1279.  
  1280.     if (sp->sstate != SOCK_STATE_CONNECTED) 
  1281.         return(sock_err(ENOTCONN));
  1282.  
  1283.     sock_copy_addr(&sockets[s].peer, name, namelen);
  1284.  
  1285.     return(0);
  1286. }
  1287.  
  1288. /*
  1289.  *    s_shutdown(s, how)
  1290.  *
  1291.  *        shutdown call causes all or part of a full-duplex
  1292.  *        connection on the socket s to be shut down.  If
  1293.  *        how is 0, then further receives will be disallowed.  If  how
  1294.  *        is  1,  then further sends will be disallowed.  If how is 2,
  1295.  *        then further sends and receives will be disallowed.
  1296.  *        
  1297.  *        A 0 is returned if the call succeeds, -1 if it fails.
  1298.  */
  1299. int s_shutdown(
  1300.     Int4 s,
  1301.     Int4 how)
  1302. {
  1303.     SocketPtr sp;
  1304.     
  1305. #if SOCK_DEBUG >= 2
  1306.     dprintf("shutdown: shutdown %d\n", s);
  1307. #endif
  1308.     if (! sock_good_fd(s))
  1309.         return(sock_err(EBADF));
  1310.     sp = sockets+s;
  1311.  
  1312.     switch(how) 
  1313.     {
  1314.         case 0 : 
  1315.             sp->status |= SOCK_STATUS_NOREAD;
  1316.             break;
  1317.             
  1318.         case 1 : 
  1319.             sp->status |= SOCK_STATUS_NOWRITE;
  1320.             break;
  1321.  
  1322.         case 2 :
  1323.             sp->status |= SOCK_STATUS_NOREAD | SOCK_STATUS_NOWRITE;
  1324.             break;
  1325.             
  1326.         default :
  1327.             return(sock_err(EINVAL));
  1328.     }
  1329.     return(0);
  1330. }
  1331.  
  1332. /*
  1333.  *    fcntl() operates on the socket s according to the order in cmd:
  1334.  *
  1335.  *        F_DUPFD    Like Dup. Returns a new descriptor which refers to the 
  1336.  *                same MacTCP stream as s and has the same descriptor 
  1337.  *                status.
  1338.  *
  1339.  *        F_GETFL    returns the descriptor status flags for s. The only
  1340.  *                flag supported is FNDELAY for non-blocking i/o.
  1341.  *
  1342.  *        F_SETFL    sets descriptor status flags for s. The only
  1343.  *                 flag supported is FNDELAY for non-blocking i/o.
  1344.  *
  1345.  *        A dup or F_DUPFD operation copies the descriptor status flags
  1346.  *        maintained by F_SETFL, but once the copy is done, the two are
  1347.  *        disjoint. THIS IS DIFFERENT FROM UNIX.
  1348.  *
  1349.  *        Upon successful completion, the value  returned  depends  on
  1350.  *        cmd as follows:
  1351.  *            F_DUPFD   A new descriptor.
  1352.  *             F_GETFL   Value of flags.
  1353.  *            F_SETFL   0.
  1354.  *
  1355.  *        On error, a value of -1  is returned and errno is set to indicate 
  1356.  *        the error.
  1357.  *
  1358.  *        EBADF           s is not a valid open descriptor.
  1359.  *
  1360.  *        EMFILE          cmd is F_DUPFD and socket descriptor table is full.
  1361.  *
  1362.  *        EINVAL          cmd is F_DUPFD and arg  is  negative  or
  1363.  *                      greater   than   the  maximum  allowable
  1364.  *                      number (see getdtablesize).
  1365.  */
  1366. int s_fcntl(
  1367.     Int4 s,
  1368.     /* unsigned Int4 cmd,*/
  1369.     unsigned long cmd,
  1370.     Int4 arg)
  1371. {
  1372. #if SOCK_DEBUG >= 2
  1373.     dprintf("s_fcntl: %d\n", s);
  1374. #endif
  1375.  
  1376.     if (! sock_good_fd(s))
  1377.         return(sock_err(EBADF));
  1378.  
  1379.     switch(cmd) 
  1380.     {
  1381.         /*
  1382.          * Duplicate a socket.
  1383.          */
  1384.         case F_DUPFD : 
  1385.         {
  1386.             int s1;
  1387.             
  1388.             if (arg < 0 || arg >= NUM_SOCKETS)
  1389.                 return(sock_err(EINVAL));
  1390.             
  1391.             s1 = sock_free_fd(arg);
  1392.             if (s1 == -1)
  1393.                 return(sock_err(EMFILE));
  1394.             
  1395.             sock_dup_fd(s,s1);
  1396.             return(s1);
  1397.         }
  1398.         
  1399.         /*
  1400.          *  Get socket status.  This is like getsockopt().
  1401.          *  Only supported descriptor status is FNDELAY.
  1402.          */
  1403.         case F_GETFL : 
  1404.         {
  1405.             SocketPtr sp;
  1406.     
  1407.             sp = sockets+s;
  1408.             if (sp->nonblocking)
  1409.                 return(FNDELAY);
  1410.             else
  1411.                 return(0);
  1412.         }
  1413.         
  1414.         /*
  1415.          *  Set socket status.  This is like setsockopt().
  1416.          *  Only supported descriptor status is FNDELAY.
  1417.          */
  1418.         case F_SETFL : 
  1419.         {
  1420.             SocketPtr sp;
  1421.     
  1422.             sp = sockets+s;
  1423.             if (arg & FNDELAY)
  1424.                 sp->nonblocking = true;
  1425.             else
  1426.                 sp->nonblocking = false;
  1427.             
  1428.             return(0);
  1429.         }
  1430.     }
  1431.     return(0);
  1432. }
  1433.  
  1434. /*
  1435.  *    dup(s)
  1436.  *
  1437.  *    dup2(s, news)
  1438.  *
  1439.  *        dup() duplicates an existing socket descriptor.   The  argu-
  1440.  *        ment s is a small non-negative integer index in the per-
  1441.  *        process descriptor table.  The value must be less  than  the
  1442.  *        size  of  the  table, which is returned by getdtablesize(2).
  1443.  *        The new descriptor returned by the call is the  lowest  num-
  1444.  *        bered  descriptor  that  is not currently in use by the pro-
  1445.  *        cess.
  1446.  *
  1447.  *        In the second form  of  the  call,  the  value  of  the  new
  1448.  *        descriptor  desired  is  specified.   If  that descriptor is
  1449.  *        already in use, the descriptor is first deallocated as if  a
  1450.  *        close(2) call had been done first.
  1451.  *
  1452.  *        The value -1 is returned if an error occurs in either  call.
  1453.  *        The  external  variable  errno  indicates  the  cause of the
  1454.  *        error.
  1455.  *
  1456.  *        EBADF               s or  news is  not  a  valid  socket
  1457.  *                            descriptor.
  1458.  *
  1459.  *        EMFILE              Too many descriptors are active.
  1460.  */
  1461. int s_dup(
  1462.     Int4 s)
  1463. {
  1464.     return(s_fcntl(s, F_DUPFD, 0));
  1465. }
  1466.  
  1467. int s_dup2(
  1468.     Int4 s,
  1469.     Int4 s1)
  1470. {
  1471.     if (! sock_good_fd(s))
  1472.         return(sock_err(EBADF));
  1473.  
  1474.     if (s1 < 0 || s1 >= NUM_SOCKETS)
  1475.         return(sock_err(EBADF));
  1476.  
  1477.     if (is_used(sockets+s1))
  1478.     {
  1479.         if (s_close(s1) == -1)
  1480.             return(-1);
  1481.     }
  1482.     sock_dup_fd(s,s1);
  1483.     return(s1);
  1484. }
  1485.  
  1486.  
  1487. /*
  1488.  * s_Ioctl()
  1489.  */
  1490. int s_ioctl(
  1491.     Int4 d,
  1492.     Int4 request,
  1493.     Int4 *argp)
  1494. {
  1495.     struct    ifreq    *ifr;
  1496.     TCPiopb        *tpb;
  1497.     SocketPtr    sp;
  1498.     int            size;
  1499.  
  1500. #if SOCK_DEBUG >= 2
  1501.     dprintf("s_ioctl: %d, request %d\n", d,request);
  1502. #endif
  1503.  
  1504.     if (! sock_good_fd(d))
  1505.         return(sock_err(EBADF));
  1506.  
  1507.     sp = sockets+d;
  1508.     
  1509.     /*
  1510.      * Interpret high order word to find amount of data to be copied 
  1511.      * to/from the user's address space.
  1512.      */
  1513.     size =(request &~(IOC_INOUT | IOC_VOID)) >> 16;
  1514.     
  1515.     /*
  1516.      * Zero the buffer on the stack so the user gets back something deterministic.
  1517.      */
  1518.     if ((request & IOC_OUT) && size)
  1519.         bzero((Ptr)argp, size);
  1520.  
  1521.     ifr =(struct ifreq *)argp;
  1522.     switch(request) 
  1523.     {
  1524.         /* Non-blocking I/O */
  1525.         case FIONBIO:
  1526.             sp->nonblocking = *(Boolean *)argp;
  1527.             return(0);
  1528.  
  1529.          /* Number of bytes on input Q */
  1530.         case FIONREAD:
  1531.             tpb = (TCPiopb*)sock_fetch_pb(sp);
  1532.             sp->dataavail = xTCPBytesUnread(sp);
  1533.             *(int *)argp=sp->dataavail;
  1534.             return 0;
  1535.  
  1536. #ifdef IOCTL_LATER    
  1537.         /*
  1538.          *    Get interface list.  Pass in buffer and buffer length.
  1539.          *    Returns list of length one of ifreq's 
  1540.          */
  1541.         case SIOCGIFCONF: 
  1542.         {    
  1543.             struct ifconf *ifc =(struct ifconf *)argp;
  1544.             struct ifreq *req = ifc->ifc_req;
  1545.             int reqlen;
  1546.             struct sockaddr_in *addr;
  1547.             
  1548.             /*
  1549.              *    Fill in req fields for the IF's name and local IP addr.
  1550.              */
  1551.             strncpy(req->ifr_name, myIFName, IFNAMSIZ);
  1552.             addr =(struct sockaddr_in *)&req->ifr_addr;
  1553.             addr->sin_family         = AF_INET;
  1554.             addr->sin_addr.s_addr    = myIPAddress;
  1555.             addr->sin_port            = 0;
  1556.             bzero(addr->sin_zero, sizeof(addr->sin_zero));
  1557.             ifc->ifc_len = sizeof(*req);
  1558.                     
  1559.             return(0);            
  1560.         }
  1561.  
  1562.         /*
  1563.          *    Returns MTU of specified IF.
  1564.          */
  1565.         case SIOCGIFMTU: 
  1566.         {    
  1567.             /* don't check IF specification - we only have one anyway */
  1568.             *(int *)ifr->ifr_data= xMaxMTU();
  1569.             return(0);
  1570.         }
  1571.         
  1572.         /*
  1573.          *    Returns local IP Address of IF
  1574.          */
  1575.         case SIOCGIFADDR: 
  1576.         {
  1577.             struct sockaddr_in *addr;
  1578.             
  1579.             /* don't check IF specification - we only have one anyway */
  1580.  
  1581.             addr = &ifr->ifr_addr;
  1582.             addr->sin_addr.s_addr = xIPAddr();
  1583.             addr->sin_family = AF_INET;
  1584.             return(0);
  1585.         }
  1586.  
  1587.         case SIOCGIFDSTADDR:         /* For point to point, which we don't support */
  1588.             return(sock_err(EINVAL));
  1589.  
  1590.         case SIOCGIFFLAGS:             /* Returns IF flags(none yet) */
  1591.             ifr->ifr_flags = 0;
  1592.             return(0);
  1593.             
  1594.         /*
  1595.          *    Return broadcast address - net address plus all ones in host part
  1596.          */
  1597.         case SIOCGIFBRDADDR:     
  1598.         {
  1599.             struct sockaddr_in *addr;
  1600.             
  1601.             /* don't check IF specification */
  1602.             /* we only have one and its broadcast  */
  1603.                 
  1604.             addr = &ifr->ifr_addr;
  1605.             addr->sin_addr.s_addr = xIPAddr() | ~xNetMask();
  1606.             return(0);
  1607.         }
  1608. #endif IOCTL_LATER    
  1609.         default :
  1610.             return(sock_err(EOPNOTSUPP));
  1611.     }
  1612. }
  1613.  
  1614. /*
  1615.  *    s_setsockopt()
  1616.  *
  1617.  *        Set socket options. None implemented. In Unix there are...
  1618.  *
  1619.  *          SO_REUSEADDR        toggle local address reuse
  1620.  *          SO_KEEPALIVE        toggle keep connections alive
  1621.  *          SO_DONTROUTE        toggle routing bypass for  outgoing
  1622.  *                              messages
  1623.  *          SO_LINGER           linger on close if data present
  1624.  *          SO_BROADCAST        toggle   permission   to   transmit
  1625.  *                              broadcast messages
  1626.  *          SO_OOBINLINE        toggle  reception  of   out-of-band
  1627.  *                              data in band
  1628.  *          SO_SNDBUF           set buffer size for output
  1629.  *          SO_RCVBUF           set buffer size for input
  1630.  *          SO_TYPE             get the type  of  the  socket  (get
  1631.  *                              only)
  1632.  *          SO_ERROR            get and clear error on  the  socket
  1633.  *                             (get only)
  1634.  */
  1635. int s_setsockopt(
  1636.     Int4 s,
  1637.     Int4 level,
  1638.     Int4 optname,
  1639.     char *optval,
  1640.     Int4 optlen)
  1641. {
  1642. #pragma unused(optval)
  1643. #pragma unused(optlen)
  1644.     SocketPtr sp;
  1645.  
  1646. #if SOCK_DEBUG >= 3
  1647.     dprintf("SETSOCKOPT:  socket: %d  option: %d  \n", s,optname);
  1648. #endif
  1649.     if (! sock_good_fd(s))
  1650.         return(sock_err(EBADF));
  1651.  
  1652.     sp = sockets+s;
  1653.  
  1654.     /*
  1655.      * demultiplex to socket option handlers at other protocol levels.(None
  1656.      * supported yet).
  1657.      */
  1658.     switch(level) 
  1659.     {
  1660.         case SOL_SOCKET :         /* socket level option */
  1661.             switch(optname) 
  1662.             {
  1663.                 default :
  1664.                     return(0);
  1665.             }
  1666.             break;
  1667.         case IPPROTO_TCP:
  1668.             switch(optname)
  1669.             {
  1670.                 default:
  1671.                     return(0);
  1672.             }
  1673.             break;
  1674.         default :
  1675.             return(sock_err(ENOPROTOOPT));
  1676.     }
  1677.     return(0);
  1678. }
  1679.  
  1680.  
  1681. /*
  1682.  * s_setspin() - define a routine to be called repeatedly when
  1683.  *                 socket routines are blocked (ie. spinning)
  1684.  *
  1685.  *                 pass a NULL pointer to turn off a previously
  1686.  *                 defined spin routine.
  1687.  */
  1688. int s_setspin(
  1689.     SpinFn routine)
  1690. {
  1691.     if (routine == NULL || goodptr(routine))
  1692.         {
  1693.         spinroutine = routine;
  1694.         return(0);
  1695.         }
  1696.     else
  1697.         return(sock_err(EFAULT));
  1698. }
  1699.  
  1700. /*
  1701.  * s_getspin() - returns current spinroutine
  1702.  */
  1703. SpinFn s_getspin()
  1704.     {
  1705.     return (spinroutine);
  1706.     }
  1707.  
  1708.  
  1709. int defaultSpin(spin_msg msg,long param)
  1710.     {
  1711. #pragma unused (msg,param)
  1712.     EventRecord evrec;
  1713.     
  1714.     WaitNextEvent(0, &evrec, 1 /* ticks */, NULL);
  1715.     return 0;        /* return non-zero to exit current routine */
  1716.     }
  1717.